// #include <cstring>
// #include <cassert>
// #include <iostream>

// using std::endl;
// using std::cout;
// using std::cin;

// // 实现一个简单的string,只考虑资源管理,不考虑增删查改
// class string
// {
// public:
//     string(const char* str = "")
//     {
//         if(str == nullptr)
//         {
//             assert(false);
//             return;
//         }

//         _str = new char[strlen(str) + 1]; // 加一是因为strcpy()会拷贝'\0'
//         strcpy(_str, str);
//     }

//     string(const string& s)
//     {
//         _str = new char[strlen(s._str) + 1];
//         strcpy(_str, s._str);
//     }

//     string& operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             char* tmp = new char[strlen(s._str) + 1];
//             strcpy(tmp, s._str);
//             delete[] _str;
//             _str = tmp;
//         }

//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }


// private:
//     char* _str;
// };


// 实现一个简单的string类,只考虑资源管理深浅拷贝问题
// class string
// {
// public:
//     string(const char* str)
//         : _str(new char[strlen(str) + 1])
//     {
//         strcpy(_str, str);
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

//     string(const string& s)
//         : _str(new char[strlen(s._str) + 1])
//     {
//         strcpy(_str, s._str);
//     }

//     string& operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             char* tmp = new char[strlen(s._str) + 1];
//             strcpy(tmp, s._str);
//             delete[] _str;
//             _str = tmp;
//         }

//         return *this;
//     }

//     const char* c_str() const
//     {
//         return _str;
//     }

//     char operator[](int pos)
//     {
//         assert(pos < strlen(_str));
        
//         return _str[pos];
//     }

//     int size()const
//     {
//         return strlen(_str);
//     }



// private:
//     char* _str;
// };


// #include <iostream>
// #include <cstring>
// #include <cassert>

// using std::cin;
// using std::cout;
// using std::endl;


// class string
// {
// public:
//     typedef char* iterator;
//     typedef const char* const_iterator;

// public:
//     string(const char* str = "")
//         // 注意初始化列表初始化顺序就是变量的声明顺序
//         : _size(strlen(str))
//         , _capacity(_size)
//     {
//         _str = new char[_capacity + 1];
//         strcpy(_str, str);
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//             _size = 0;
//             _capacity = 0;
//         }
//     }

//     // string s2(s1);
//     string(const string& s)
//         : _size(s._size)
//         , _capacity(_size)
//     {
//         _str = new char[_capacity + 1];
//         strcpy(_str, s._str);
//     }


//     // s1 = s2
//     string& operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             char* tmp = new char[s._capacity + 1];
//             strcpy(tmp, s._str);
//             delete[] _str;
//             _str = tmp;
//             _size = s._size;
//             _capacity = s._capacity;
//         }

//         return *this;
//     }

//     size_t capacity() const
//     {
//         return _capacity;
//     }

//     size_t size() const
//     {
//         return _size;
//     }

//     const char* c_str() const
//     {
//         return _str;
//     }

//     char& operator[](size_t pos)
//     {
//         assert(pos < _size);

//         return _str[pos];
//     }

//     const char& operator[](size_t pos) const
//     {
//         assert(pos < _size);

//         return _str[pos];
//     }

//     // 单纯扩空间 - 即使n<_capacity也不会缩容
//     void reserve(size_t n)
//     {
//         if(n > _capacity)
//         {
//             char* tmp = new char[n + 1];
//             strcpy(tmp, _str);
//             delete[] _str;
//             _str = nullptr;
//             _capacity = n;
//         }
//     }

//     // resize()作用分为两种: 一是扩空间+初始化; 二是删除部分数据,保留前N个
//     void resize(size_t n, char ch = '\0')
//     {
//         if(n < _size)
//         {
//             _size = n;
//             _str[_size] = '\0';
//         }
//         else
//         {
//             if(n > _capacity)
//             {
//                 reserve(n);
//             }

//             for(size_t i = _size; i < n; i++)
//             {
//                 _str[i] = ch;
//             }
//             _size = n;
//             _str[_size] = '\0';
//         }
//     }


//     void push_back(char ch)
//     {
//         if(_size == _capacity)
//         {
//             reserve(_capacity == 0 ? 4 : _capacity * 2);
//         }

//         _str[_size] = ch;
//         _size++;
//         _str[_size] = '\0'; // 与顺序表不同,最后记得还需处理'\0'
//     }

//     string& operator+=(char ch)
//     {
//         push_back(ch);

//         return *this;
//     }

//     void append(const char* str)
//     {
//         size_t len = _size + strlen(str);

//         if(len > _capacity)
//         {
//             reserve(len);
//         }

//         strcpy(_str + _size, str);
//         _size = len;
//     }


//     string operator+=(const char* str)
//     {
//         append(str);

//         return *this;
//     }


//     iterator begin() // 迭代器:像指针一样或者就是指针(具体根据容器的底层结构而定)
//     {
//         return _str;
//     }

//     const_iterator begin() const
//     {
//         return _str;
//     }

//     iterator end()
//     {
//         return _str + _size;
//     }

//     const_iterator end() const
//     {
//         return _str + _size;
//     }

//     string insert(size_t pos, char ch)
//     {
//         assert(pos <= _size);

//         if(_size == _capacity)
//             reserve(_capacity == 0 ? 4 : _capacity * 2);

//         // size_t 类型使用时的注意事项就是避免出现减到-1的情况
//         size_t end = _size + 1;
//         while(end > pos)
//         {
//             _str[end] = _str[end - 1];
//             end--;
//         }
//         _str[pos] = ch;
//         _size++;

//         return *this;
//     }

//     string& insert(size_t pos, const char* str)
//     {
//         assert(pos <= _size);

//         size_t len = strlen(str);
//         if(_size + len > _capacity)
//         {
//             reserve(_size + len);
//         }
//         // 往后挪len个位置
//         size_t end = _size + len;
//         while(end > pos + len - 1)
//         {
//             _str[end] = _str[end - len];
//             end--;
//         }

//         strncpy(_str + pos, str, len); // strcpy()会拷贝'\0'
//         _size += len;

//         return *this;
//     }

//     string& erase(size_t pos, size_t len = npos)
//     {
//         assert(pos < _size);

//         if(len == npos || len + pos >= _size)
//         {
//             _str[pos] = '\0';
//             _size = pos;
//         }
//         else
//         {
//             size_t begin = pos + len;
//             while(begin <= _size)
//             {
//                 _str[begin - len] = _str[begin];
//                 begin++;
//             }

//             _size -= len;
//         }

//         return *this;
//     }

//     size_t find(const char* str, size_t pos = 0) const
//     {
//         const char* p = strstr(_str + pos, str);

//         if(p == nullptr)
//             return npos;
//         else
//             return p - _str;
//     }



// private:
//     char* _str;
//     size_t _size; // 有效字符的个数
//     size_t _capacity; // 实际存储有效字符的空间

//     const static size_t npos = -1;
// };



// 传统写法: 本分老老实实干活,该开空间自己开空间,该拷贝数据自己拷贝数据
// 现代写法: 剥削,要完成深拷贝,自己不想干活,安排别人干活,然后窃取劳动成果
#include <iostream>
#include <cstring>
#include <algorithm>
using std::cin;
using std::cout;
using std::endl;

class string
{
public:
    string(const char* str = "")
        : _size(strlen(str))
        , _capacity(_size)
    {
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }

    ~string()
    {
        if(_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }

    string(const string& s)
        : _str(nullptr)
        , _size(0)
        , _capacity(0)
    {
        string tmp(s._str);
        swap(tmp);
    }

    string& operator=(string s) // 传参的时候就已经完成了深拷贝
    {
        swap(s);

        return *this;
    }

    void swap(string& s)
    {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }

private:
    char* _str;
    size_t _size; // 有效字符的个数
    size_t _capacity; // 实际存储有效字符的空间
};